package com.gitee.huanminabc.utils_tools.redis.redisson.utils;

import com.gitee.huanminabc.utils_tools.redis.aspect.handler.RedisSwitchAspect;
import com.gitee.huanminabc.utils_tools.redis.redisson.config.RedissonConfig;
import org.redisson.api.*;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;

import java.time.Duration;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @author huanmin
 * @date 2024/2/5
 */

@Component
public class RedissonUtil {
    //从配置类中获取redisson对象,可以自动切换数据库
    public RedissonClient getRedissonClient() {
        return RedissonConfig.redissonClientMap.get(RedisSwitchAspect.dbIndex.get());
    }







    //==============================================key ,value操作
    /**
     * 新增字符串数据
     *
     * @param name   名称
     * @param value 值
     * @return 返回 是否新增成功
     */
    public boolean set(String name, Object value) {
        getRedissonClient().getBucket(name).set(value);
        return true;
   }
    //新增字符串数据,并设置过期时间 ,单位秒
    public boolean set(String name, Object value, long time) {
        RBucket<Object> bucket = getRedissonClient().getBucket(name);
        bucket.set(value, time, TimeUnit.SECONDS);
        return true;
    }

    /**
     * 获取字符串数据
     *
     * @param name 名称
     * @return 返回 值
     */
    public <V> V get(String name, Class<V> vClass) {
        RBucket<V> bucket = getRedissonClient().getBucket(name);
        return bucket.get();
    }
    /**
     * 删除字符串数据
     *
     * @param name 名称
     * @return 返回 是否删除成功
     */
    public boolean delete(String name) {
        return getRedissonClient().getBucket(name).delete();
    }

    //设置过期时间 ,单位秒
    public boolean expire(String name, long time) {
        Duration duration = Duration.ofSeconds(time);
        return getRedissonClient().getBucket(name).expire(duration);
    }

//==========================================================================List集合 操作
    //新增 list 数据
    public <V> boolean lSet(String name, V value) {
        return getRedissonClient().getList(name).add(value);
    }
    //新增 list 数据,并设置过期时间 ,单位秒
    public <V> boolean lSet(String name, V value, long time) {
        getRedissonClient().getList(name).add(value);
        getRedissonClient().getList(name).expire(Duration.ofSeconds(time));
        return true;
    }
    //批量新增 list 数据
    public <V> boolean lSet(String name, List<V> values) {
        return getRedissonClient().getList(name).addAll(values);
    }
    //批量新增 list 数据,并设置过期时间 ,单位秒
    public <V> boolean lSet(String name, List<V> values, long time) {
        RSet<V> set = getRedissonClient().getSet(name);
        set.addAll(values);
        set.expire(Duration.ofSeconds(time));
        return true;
    }
    //读取 list 数据
    public <V> List<V> lReadAll(String name, Class<V> vClass) {
        RList<V> list = getRedissonClient().getList(name);
        return list.readAll();
    }
    //删除 list
    public boolean lDelete(String name) {
        return getRedissonClient().getList(name).delete();
    }
    //删除 list 数据
    public <V> boolean lDelete(String name, V value) {
        return getRedissonClient().getList(name).remove(value);
    }
    //删除 list 数据
    public <V> boolean lDelete(String name, List<V> values) {
        return getRedissonClient().getList(name).removeAll(values);
    }
    //设置list过期时间 ,单位秒
    public boolean lExpire(String name, long time) {
        Duration duration = Duration.ofSeconds(time);
        return getRedissonClient().getList(name).expire(duration);
    }
    //获取list的长度
    public long lSize(String name) {
        return getRedissonClient().getList(name).size();
    }
    //获取list的指定范围的数据
    public <V> List<V> lRange(String name, int start, int end, Class<V> vClass) {
        RList<V> list = getRedissonClient().getList(name);
        return list.range(start, end);
    }
    //删除list的指定范围的数据
    public <V> boolean lTrim(String name, int start, int end) {
        RList<V> list = getRedissonClient().getList(name);
        list.trim(start, end);
        return true;
    }
    //获取list的指定位置的数据
    public <V> V lIndex(String name, int index, Class<V> vClass) {
        RList<V> list = getRedissonClient().getList(name);
        return list.get(index);
    }
    //在list的指定位置插入数据
    public <V> boolean lInsert(String name, int index, V value) {
        RList<V> list = getRedissonClient().getList(name);
        list.add(index, value);
        return true;
    }
    //在list的指定位置插入数据,并设置过期时间 ,单位秒
    public <V> boolean lInsert(String name, int index, V value, long time) {
        RList<V> list = getRedissonClient().getList(name);
        list.add(index, value);
        list.expire(Duration.ofSeconds(time));
        return true;
    }

    //在list的尾部插入数据
    public <V> boolean lRightPush(String name, V value) {
        RList<V> list = getRedissonClient().getList(name);
        list.add(value);
        return true;
    }
    //在list的尾部插入数据,并设置过期时间 ,单位秒
    public <V> boolean lRightPush(String name, V value, long time) {
        RList<V> list = getRedissonClient().getList(name);
        list.add(value);
        list.expire(Duration.ofSeconds(time));
        return true;
    }
    //在list的头部插入数据
    public <V> boolean lLeftPush(String name, V value) {
        RList<V> list = getRedissonClient().getList(name);
        list.add(0, value);
        return true;
    }
    //在list的头部插入数据,并设置过期时间 ,单位秒
    public <V> boolean lLeftPush(String name, V value, long time) {
        RList<V> list = getRedissonClient().getList(name);
        list.add(0, value);
        list.expire(Duration.ofSeconds(time));
        return true;
    }
    //删除list的头部数据
    public <V> V lLeftPop(String name, Class<V> vClass) {
        RList<V> list = getRedissonClient().getList(name);
        return list.remove(0);
    }
    //删除list的尾部数据
    public <V> V lRightPop(String name, Class<V> vClass) {
        RList<V> list = getRedissonClient().getList(name);
        return list.remove(list.size() - 1);
    }













    //==========================================================================Set集合 操作

    /**
     * 新增 set 数据
     *
     * @param name   名称
     * @param value 值
     * @return 返回 是否新增成功
     */
    public  boolean sSet(String name, Object value) {
        return  getRedissonClient().getSet(name).add(value);
    }
    //新增 set 数据,并设置过期时间 ,单位秒
    public boolean sSet(String name, Object value, long time) {
        RSet<Object> set = getRedissonClient().getSet(name);
        set.add(value);
        set.expire(Duration.ofSeconds(time));
        return true;
    }

    /**
     * 读取 set 的数据
     *
     * @param name    名称
     * @return 返回 是否新增成功
     */
    public  <V> Set<V> sReadAll(String name, Class<V> vClass) {
        RSet<V> set = getRedissonClient().getSet(name);
        return set.readAll();
    }

    /**
     * 新增 set 数据
     *
     * @param name    名称
     * @param values 值
     * @return 返回 是否新增成功
     */
    public <V> boolean sSet(String name, List<V> values) {
        return  getRedissonClient().getSet(name).addAll(values);
    }
    //新增 set 数据,并设置过期时间 ,单位秒
    public <V> boolean sSet(String name, List<V> values, long time) {
        RSet<V> set = getRedissonClient().getSet(name);
        set.addAll(values);
        set.expire(Duration.ofSeconds(time));
        return true;
    }


    //删除 set
    public boolean sDelete(String name) {
        return getRedissonClient().getSet(name).delete();
    }
    //删除 set 数据只一个value
    public boolean sDelete(String name, String value) {
        return getRedissonClient().getSet(name).remove(value);
    }
    /**
     * 删除 set 数据
     *
     * @param name    名称
     * @param values 值
     * @return 返回 是否删除成功
     */
    public  <V>  boolean sDelete(String name, List<V> values) {
        return getRedissonClient().getSet(name).removeAll(values);
    }



    /**
     * 验证 是否包含
     *
     * @param name   名称
     * @param value 值
     * @return 返回 是否 包含
     */
    public <V> boolean sContains(String name, V value) {
        return  getRedissonClient().getSet(name).contains(value);
    }
    /**
     * 验证 是否包含
     *
     * @param name    名称
     * @param values 值
     * @return 返回 是否 包含
     */
    public <V> boolean sContainsAll(String name, List<V> values) {
        return getRedissonClient().getSet(name).containsAll(values);
    }

    //设置set过期时间 ,单位秒
    public boolean sExpire(String name, long time) {
        Duration duration = Duration.ofSeconds(time);
        return getRedissonClient().getSet(name).expire(duration);
    }


    //==========================================================================Hash集合 操作
    //新增 hash 数据
    public <K,V> boolean hSet(String name, K key, V value) {
        return getRedissonClient().getMap(name).fastPut(key, value);
    }
    //新增 hash 数据,并设置过期时间 ,单位秒
    public <K,V> boolean hSet(String name, K key, V value, long time) {
        getRedissonClient().getMap(name).fastPut(key, value);
        getRedissonClient().getMap(name).expire(Duration.ofSeconds(time));
        return true;
    }

    //读取 hash 数据
    public <K,V> V hGet(String name, K key, Class<V> vClass) {
        RMap<K, V> map = getRedissonClient().getMap(name);
        return map.get(key);
    }

    //删除 hash
    public boolean hDelete(String name) {
        return getRedissonClient().getMap(name).delete();
    }
    //删除 hash 数据
    public <K> boolean hDelete(String name, K key) {
        return getRedissonClient().getMap(name).fastRemove(key)>0;
    }
    //设置hash过期时间 ,单位秒
    public boolean hExpire(String name, long time) {
        Duration duration = Duration.ofSeconds(time);
        return getRedissonClient().getMap(name).expire(duration);
    }
    //获取hash所有的key
    public <K> Set<K> hKeys(String name, Class<K> kClass) {
        RMap<K, Object> map = getRedissonClient().getMap(name);
        return map.readAllKeySet();
    }
    //获取hash所有的value
    public <V> List<V> hValues(String name, Class<V> vClass) {
        RMap<Object, V> map = getRedissonClient().getMap(name);
        return (List<V>) map.readAllValues();
    }
    //判断hash是否存在
    public <K> boolean hContains(String name, K key) {
        return getRedissonClient().getMap(name).containsKey(key);
    }



}
